{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Devito domain specific language: an overview\n",
    "\n",
    "This notebook presents an overview of the Devito symbolic language, used to express and discretise operators, in particular partial differential equations (PDEs).\n",
    "\n",
    "For convenience, we import all Devito modules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from devito import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## From equations to code in a few lines of Python\n",
    "\n",
    "The main objective of this tutorial is to demonstrate how Devito and its [SymPy](http://www.sympy.org/en/index.html)-powered symbolic API can be used to solve partial differential equations using the finite difference method with highly optimized stencils in a few lines of Python. We demonstrate how computational stencils can be derived directly from the equation in an automated fashion and how Devito can be used to generate and execute, at runtime, the desired numerical scheme in the form of optimized C code.\n",
    "\n",
    "\n",
    "## Defining the physical domain\n",
    "\n",
    "Before we can begin creating finite-difference (FD) stencils we will need to give Devito a few details regarding the computational domain within which we wish to solve our problem. For this purpose we create a `Grid` object that stores the physical `extent` (the size) of our domain and knows how many points we want to use in each dimension to discretise our data.\n",
    "\n",
    "<img src=\"figures/grid.png\" style=\"width: 220px;\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Grid[extent=(1.0, 1.0), shape=(5, 6), dimensions=(x, y)]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid = Grid(shape=(5, 6), extent=(1., 1.))\n",
    "grid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions and data\n",
    "\n",
    "To express our equation in symbolic form and discretise it using finite differences, Devito provides a set of `Function` types. A `Function` object:\n",
    "\n",
    "1. Behaves like a `sympy.Function` symbol\n",
    "2. Manages data associated with the symbol\n",
    "\n",
    "To get more information on how to create and use a `Function` object, or any type provided by Devito, we can take a look at the documentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "    Tensor symbol representing a discrete function in symbolic equations.\n",
      "\n",
      "    A Function carries multi-dimensional data and provides operations to create\n",
      "    finite-differences approximations.\n",
      "\n",
      "    A Function encapsulates space-varying data; for data that also varies in time,\n",
      "    use TimeFunction instead.\n",
      "\n",
      "    Parameters\n",
      "    ----------\n",
      "    name : str\n",
      "        Name of the symbol.\n",
      "    grid : Grid, optional\n",
      "        Carries shape, dimensions, and dtype of the Function. When grid is not\n",
      "        provided, shape and dimensions must be given. For MPI execution, a\n",
      "        Grid is compulsory.\n",
      "    space_order : int or 3-tuple of ints, optional\n",
      "        Discretisation order for space derivatives. Defaults to 1. ``space_order`` also\n",
      "        impacts the number of points available around a generic point of interest.  By\n",
      "        default, ``space_order`` points are available on both sides of a generic point of\n",
      "        interest, including those nearby the grid boundary. Sometimes, fewer points\n",
      "        suffice; in other scenarios, more points are necessary. In such cases, instead of\n",
      "        an integer, one can pass a 3-tuple ``(o, lp, rp)`` indicating the discretization\n",
      "        order (``o``) as well as the number of points on the left (``lp``) and right\n",
      "        (``rp``) sides of a generic point of interest.\n",
      "    shape : tuple of ints, optional\n",
      "        Shape of the domain region in grid points. Only necessary if ``grid`` isn't given.\n",
      "    dimensions : tuple of Dimension, optional\n",
      "        Dimensions associated with the object. Only necessary if ``grid`` isn't given.\n",
      "    dtype : data-type, optional\n",
      "        Any object that can be interpreted as a numpy data type. Defaults\n",
      "        to ``np.float32``.\n",
      "    staggered : Dimension or tuple of Dimension or Stagger, optional\n",
      "        Define how the Function is staggered.\n",
      "    initializer : callable or any object exposing the buffer interface, optional\n",
      "        Data initializer. If a callable is provided, data is allocated lazily.\n",
      "    allocator : MemoryAllocator, optional\n",
      "        Controller for memory allocation. To be used, for example, when one wants\n",
      "        to take advantage of the memory hierarchy in a NUMA architecture. Refer to\n",
      "        `default_allocator.__doc__` for more information.\n",
      "    padding : int or tuple of ints, optional\n",
      "        .. deprecated:: shouldn't be used; padding is now automatically inserted.\n",
      "\n",
      "        Allocate extra grid points to maximize data access alignment. When a tuple\n",
      "        of ints, one int per Dimension should be provided.\n",
      "\n",
      "    Examples\n",
      "    --------\n",
      "    Creation\n",
      "\n",
      "    >>> from devito import Grid, Function\n",
      "    >>> grid = Grid(shape=(4, 4))\n",
      "    >>> f = Function(name='f', grid=grid)\n",
      "    >>> f\n",
      "    f(x, y)\n",
      "    >>> g = Function(name='g', grid=grid, space_order=2)\n",
      "    >>> g\n",
      "    g(x, y)\n",
      "\n",
      "    First-order derivatives through centered finite-difference approximations\n",
      "\n",
      "    >>> f.dx\n",
      "    Derivative(f(x, y), x)\n",
      "    >>> f.dy\n",
      "    Derivative(f(x, y), y)\n",
      "    >>> g.dx\n",
      "    Derivative(g(x, y), x)\n",
      "    >>> (f + g).dx\n",
      "    Derivative(f(x, y) + g(x, y), x)\n",
      "\n",
      "    First-order derivatives through left/right finite-difference approximations\n",
      "\n",
      "    >>> f.dxl\n",
      "    Derivative(f(x, y), x)\n",
      "\n",
      "    Note that the fact that it's a left-derivative isn't captured in the representation.\n",
      "    However, upon derivative expansion, this becomes clear\n",
      "\n",
      "    >>> f.dxl.evaluate\n",
      "    f(x, y)/h_x - f(x - h_x, y)/h_x\n",
      "    >>> f.dxr\n",
      "    Derivative(f(x, y), x)\n",
      "\n",
      "    Second-order derivative through centered finite-difference approximation\n",
      "\n",
      "    >>> g.dx2\n",
      "    Derivative(g(x, y), (x, 2))\n",
      "\n",
      "    Notes\n",
      "    -----\n",
      "    The parameters must always be given as keyword arguments, since SymPy\n",
      "    uses ``*args`` to (re-)create the dimension arguments of the symbolic object.\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "print(Function.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, let's create a function $f(x, y)$ and look at the data Devito has associated with it. Please note that it is important to use explicit keywords, such as `name` or `grid` when creating `Function` objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f{\\left(x,y \\right)}$"
      ],
      "text/plain": [
       "f(x, y)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = Function(name='f', grid=grid)\n",
    "f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Data([[0., 0., 0., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 0., 0.]], dtype=float32)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, Devito `Function` objects use the spatial dimensions `(x, y)` for 2D grids and `(x, y, z)` for 3D grids. To solve a PDE over several timesteps a time dimension is also required by our symbolic function. For this Devito provides an additional function type, the `TimeFunction`, which incorporates the correct dimension along with some other intricacies needed to create a time stepping scheme."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle g{\\left(t,x,y \\right)}$"
      ],
      "text/plain": [
       "g(t, x, y)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g = TimeFunction(name='g', grid=grid)\n",
    "g"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the default time order of a `TimeFunction` is `1`, the shape of `f` is `(2, 5, 6)`, i.e. Devito has allocated two buffers to represent `g(t, x, y)` and `g(t + dt, x, y)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 5, 6)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Derivatives of symbolic functions\n",
    "\n",
    "The functions we have created so far all act as `sympy.Function` objects, which means that we can form symbolic derivative expressions from them. Devito provides a set of shorthand expressions (implemented as Python properties) that allow us to generate finite differences in symbolic form. For example, the property `f.dx` denotes $\\frac{\\partial}{\\partial x} f(x, y)$ - only that Devito has already discretised it with a finite difference expression. There are also a set of shorthand expressions for left (backward) and right (forward) derivatives:\n",
    "\n",
    "| Derivative | Shorthand | Discretised | Stencil |\n",
    "| ---------- |:---------:|:-----------:|:-------:|\n",
    "| $\\frac{\\partial}{\\partial x}f(x, y)$ (right) | `f.dxr` | $\\frac{f(x+h_x,y)}{h_x} - \\frac{f(x,y)}{h_x}$ | <img src=\"figures/stencil_forward.png\" style=\"width: 180px;\"/> |\n",
    "| $\\frac{\\partial}{\\partial x}f(x, y)$ (left) | `f.dxl` | $\\frac{f(x,y)}{h_x} - \\frac{f(x-h_x,y)}{h_x}$ | <img src=\"figures/stencil_backward.png\" style=\"width: 180px;\"/> |\n",
    "\n",
    "A similar set of expressions exist for each spatial dimension defined on our grid, for example `f.dy` and `f.dyl`. Obviously, one can also take derivatives in time of `TimeFunction` objects. For example, to take the first derivative in time of `g` you can simply write:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial}{\\partial t} g{\\left(t,x,y \\right)}$"
      ],
      "text/plain": [
       "Derivative(g(t, x, y), t)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.dt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We may also want to take a look at the stencil Devito will generate based on the chosen discretisation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{g{\\left(t,x,y \\right)}}{dt} + \\frac{g{\\left(t + dt,x,y \\right)}}{dt}$"
      ],
      "text/plain": [
       "-g(t, x, y)/dt + g(t + dt, x, y)/dt"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.dt.evaluate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There also exist convenient shortcuts to express the forward and backward stencil points, `g(t+dt, x, y)` and `g(t-dt, x, y)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle g{\\left(t + dt,x,y \\right)}$"
      ],
      "text/plain": [
       "g(t + dt, x, y)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.forward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle g{\\left(t - dt,x,y \\right)}$"
      ],
      "text/plain": [
       "g(t - dt, x, y)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.backward"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And of course, there's nothing to stop us taking derivatives on these objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial}{\\partial t} g{\\left(t + dt,x,y \\right)}$"
      ],
      "text/plain": [
       "Derivative(g(t + dt, x, y), t)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.forward.dt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial}{\\partial y} g{\\left(t + dt,x,y \\right)}$"
      ],
      "text/plain": [
       "Derivative(g(t + dt, x, y), y)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.forward.dy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A linear convection operator\n",
    "\n",
    "**Note:** The following example is derived from [step 5](http://nbviewer.ipython.org/github/barbagroup/CFDPython/blob/master/lessons/07_Step_5.ipynb) in the excellent tutorial series [CFD Python: 12 steps to Navier-Stokes](http://lorenabarba.com/blog/cfd-python-12-steps-to-navier-stokes/).\n",
    "\n",
    "In this simple example we will show how to derive a very simple convection operator from a high-level description of the governing equation. We will go through the process of deriving a discretised finite difference formulation of the state update for the field variable $u$, before creating a callable `Operator` object. Luckily, the automation provided by SymPy makes the derivation very nice and easy.\n",
    "\n",
    "The governing equation we want to implement is the linear convection equation:\n",
    "$$\\frac{\\partial u}{\\partial t}+c\\frac{\\partial u}{\\partial x} + c\\frac{\\partial u}{\\partial y} = 0.$$\n",
    "\n",
    "Before we begin, we must define some parameters including the grid, the number of timesteps and the timestep size. We will also initialize our velocity `u` with a smooth field:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "tags": [
     "nbval-ignore-output"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1100x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from examples.cfd import init_smooth, plot_field\n",
    "\n",
    "nt = 100  # Number of timesteps\n",
    "dt = 0.2 * 2. / 80  # Timestep size (sigma=0.2)\n",
    "c = 1  # Value for c\n",
    "\n",
    "# Then we create a grid and our function\n",
    "grid = Grid(shape=(81, 81), extent=(2., 2.))\n",
    "u = TimeFunction(name='u', grid=grid)\n",
    "\n",
    "# We can now set the initial condition and plot it\n",
    "init_smooth(field=u.data[0], dx=grid.spacing[0], dy=grid.spacing[1])\n",
    "init_smooth(field=u.data[1], dx=grid.spacing[0], dy=grid.spacing[1])\n",
    "\n",
    "plot_field(u.data[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we wish to discretise our governing equation so that a functional `Operator` can be created from it. We begin by simply writing out the equation as a symbolic expression, while using shorthand expressions for the derivatives provided by the `Function` object. This will create a symbolic object of the dicretised equation.\n",
    "\n",
    "Using the Devito shorthand notation, we can express the governing equations as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial}{\\partial x} u{\\left(t,x,y \\right)} + \\frac{\\partial}{\\partial y} u{\\left(t,x,y \\right)} + \\frac{\\partial}{\\partial t} u{\\left(t,x,y \\right)} = 0$"
      ],
      "text/plain": [
       "Eq(Derivative(u(t, x, y), x) + Derivative(u(t, x, y), y) + Derivative(u(t, x, y), t), 0)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq = Eq(u.dt + c * u.dxl + c * u.dyl)\n",
    "eq"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now need to rearrange our equation so that the term $u(t+dt, x, y)$ is on the left-hand side, since it represents the next point in time for our state variable $u$. Devito provides a utility called `solve`, built on top of SymPy's `solve`, to rearrange our equation so that it represents a valid state update for $u$. Here, we use `solve` to create a valid stencil for our update to `u(t+dt, x, y)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle u{\\left(t + dt,x,y \\right)} = \\frac{- dt h_{x} u{\\left(t,x,y \\right)} + dt h_{x} u{\\left(t,x,y - h_{y} \\right)} - dt h_{y} u{\\left(t,x,y \\right)} + dt h_{y} u{\\left(t,x - h_{x},y \\right)} + h_{x} h_{y} u{\\left(t,x,y \\right)}}{h_{x} h_{y}}$"
      ],
      "text/plain": [
       "Eq(u(t + dt, x, y), (-dt*h_x*u(t, x, y) + dt*h_x*u(t, x, y - h_y) - dt*h_y*u(t, x, y) + dt*h_y*u(t, x - h_x, y) + h_x*h_y*u(t, x, y))/(h_x*h_y))"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stencil = solve(eq, u.forward)\n",
    "update = Eq(u.forward, stencil)\n",
    "update"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The right-hand side of the 'update' equation should be a stencil of the shape\n",
    "<img src=\"figures/stencil_convection.png\" style=\"width: 160px;\"/>\n",
    "\n",
    "Once we have created this 'update' expression, we can create a Devito `Operator`. This `Operator` will basically behave like a Python function that we can call to apply the created stencil over our associated data, as long as we provide all necessary unknowns. In this case we need to provide the number of timesteps to compute via the keyword `time` and the timestep size via `dt` (both have been defined above):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "tags": [
     "nbval-ignore-output"
    ]
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Kernel` run in 0.01 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1100x700 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "op = Operator(update)\n",
    "op(time=nt+1, dt=dt)\n",
    "\n",
    "plot_field(u.data[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the real power of Devito is hidden within `Operator`, it will automatically generate and compile the optimized C code. We can look at this code (noting that this is not a requirement of executing it) via:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "tags": [
     "nbval-ignore-output"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#define _POSIX_C_SOURCE 200809L\n",
      "#include \"stdlib.h\"\n",
      "#include \"math.h\"\n",
      "#include \"sys/time.h\"\n",
      "\n",
      "struct dataobj\n",
      "{\n",
      "  void *restrict data;\n",
      "  int * size;\n",
      "  int * npsize;\n",
      "  int * dsize;\n",
      "  int * hsize;\n",
      "  int * hofs;\n",
      "  int * oofs;\n",
      "} ;\n",
      "\n",
      "struct profiler\n",
      "{\n",
      "  double section0;\n",
      "} ;\n",
      "\n",
      "\n",
      "int Kernel(const float dt, const float h_x, const float h_y, struct dataobj *restrict u_vec, const int time_M, const int time_m, struct profiler * timers, const int x_M, const int x_m, const int y_M, const int y_m)\n",
      "{\n",
      "  float (*restrict u)[u_vec->size[1]][u_vec->size[2]] __attribute__ ((aligned (64))) = (float (*)[u_vec->size[1]][u_vec->size[2]]) u_vec->data;\n",
      "  for (int time = time_m, t0 = (time)%(2), t1 = (time + 1)%(2); time <= time_M; time += 1, t0 = (time)%(2), t1 = (time + 1)%(2))\n",
      "  {\n",
      "    struct timeval start_section0, end_section0;\n",
      "    gettimeofday(&start_section0, NULL);\n",
      "    /* Begin section0 */\n",
      "    for (int x = x_m; x <= x_M; x += 1)\n",
      "    {\n",
      "      for (int y = y_m; y <= y_M; y += 1)\n",
      "      {\n",
      "        u[t1][x + 1][y + 1] = (dt*h_x*u[t0][x + 1][y] + dt*h_y*u[t0][x][y + 1] + h_x*h_y*u[t0][x + 1][y + 1] - (dt*h_x*u[t0][x + 1][y + 1] + dt*h_y*u[t0][x + 1][y + 1]))/(h_x*h_y);\n",
      "      }\n",
      "    }\n",
      "    /* End section0 */\n",
      "    gettimeofday(&end_section0, NULL);\n",
      "    timers->section0 += (double)(end_section0.tv_sec-start_section0.tv_sec)+(double)(end_section0.tv_usec-start_section0.tv_usec)/1000000;\n",
      "  }\n",
      "  return 0;\n",
      "}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(op.ccode)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Second derivatives and high-order stencils\n",
    "\n",
    "In the above example only a combination of first derivatives was present in the governing equation. However, second (or higher) order derivatives are often present in scientific problems of interest, notably any PDE modeling diffusion. To generate second order derivatives we must give the `devito.Function` object another piece of information: the desired discretisation of the stencil(s).\n",
    "\n",
    "First, lets define a simple second derivative in `x`, for which we need to give $u$ a `space_order` of (at least) `2`. The shorthand for this second derivative is `u.dx2`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial^{2}}{\\partial x^{2}} u{\\left(t,x,y \\right)}$"
      ],
      "text/plain": [
       "Derivative(u(t, x, y), (x, 2))"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u = TimeFunction(name='u', grid=grid, space_order=2)\n",
    "u.dx2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{2.0 u{\\left(t,x,y \\right)}}{h_{x}^{2}} + \\frac{u{\\left(t,x - h_{x},y \\right)}}{h_{x}^{2}} + \\frac{u{\\left(t,x + h_{x},y \\right)}}{h_{x}^{2}}$"
      ],
      "text/plain": [
       "-2.0*u(t, x, y)/h_x**2 + u(t, x - h_x, y)/h_x**2 + u(t, x + h_x, y)/h_x**2"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u.dx2.evaluate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can increase the discretisation arbitrarily if we wish to specify higher order FD stencils:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial^{2}}{\\partial x^{2}} u{\\left(t,x,y \\right)}$"
      ],
      "text/plain": [
       "Derivative(u(t, x, y), (x, 2))"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u = TimeFunction(name='u', grid=grid, space_order=4)\n",
    "u.dx2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{2.5 u{\\left(t,x,y \\right)}}{h_{x}^{2}} - \\frac{0.0833333333 u{\\left(t,x - 2 h_{x},y \\right)}}{h_{x}^{2}} + \\frac{1.33333333 u{\\left(t,x - h_{x},y \\right)}}{h_{x}^{2}} + \\frac{1.33333333 u{\\left(t,x + h_{x},y \\right)}}{h_{x}^{2}} - \\frac{0.0833333333 u{\\left(t,x + 2 h_{x},y \\right)}}{h_{x}^{2}}$"
      ],
      "text/plain": [
       "-2.5*u(t, x, y)/h_x**2 - 0.0833333333*u(t, x - 2*h_x, y)/h_x**2 + 1.33333333*u(t, x - h_x, y)/h_x**2 + 1.33333333*u(t, x + h_x, y)/h_x**2 - 0.0833333333*u(t, x + 2*h_x, y)/h_x**2"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u.dx2.evaluate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To implement the diffusion or wave equations, we must take the Laplacian $\\nabla^2 u$, which is the sum of the second derivatives in all spatial dimensions. For this, Devito also provides a shorthand expression, which means we do not have to hard-code the problem dimension (2D or 3D) in the code. To change the problem dimension we can create another `Grid` object and use this to re-define our `Function`'s:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle u{\\left(t,x,y,z \\right)}$"
      ],
      "text/plain": [
       "u(t, x, y, z)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid_3d = Grid(shape=(5, 6, 7), extent=(1., 1., 1.))\n",
    "\n",
    "u = TimeFunction(name='u', grid=grid_3d, space_order=2)\n",
    "u"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can re-define our function `u` with a different `space_order` argument to change the discretisation order of the stencil expression created. For example, we can derive an expression of the 12th-order Laplacian $\\nabla^2 u$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial^{2}}{\\partial x^{2}} u{\\left(t,x,y,z \\right)} + \\frac{\\partial^{2}}{\\partial y^{2}} u{\\left(t,x,y,z \\right)} + \\frac{\\partial^{2}}{\\partial z^{2}} u{\\left(t,x,y,z \\right)}$"
      ],
      "text/plain": [
       "Derivative(u(t, x, y, z), (x, 2)) + Derivative(u(t, x, y, z), (y, 2)) + Derivative(u(t, x, y, z), (z, 2))"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u = TimeFunction(name='u', grid=grid_3d, space_order=12)\n",
    "u.laplace"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same expression could also have been generated explicitly via:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial^{2}}{\\partial x^{2}} u{\\left(t,x,y,z \\right)} + \\frac{\\partial^{2}}{\\partial y^{2}} u{\\left(t,x,y,z \\right)} + \\frac{\\partial^{2}}{\\partial z^{2}} u{\\left(t,x,y,z \\right)}$"
      ],
      "text/plain": [
       "Derivative(u(t, x, y, z), (x, 2)) + Derivative(u(t, x, y, z), (y, 2)) + Derivative(u(t, x, y, z), (z, 2))"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u.dx2 + u.dy2 + u.dz2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Derivatives of composite expressions\n",
    "\n",
    "Derivatives of any arbitrary expression can easily be generated:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "u = TimeFunction(name='u', grid=grid, space_order=2)\n",
    "v = TimeFunction(name='v', grid=grid, space_order=2, time_order=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial^{2}}{\\partial x^{2}} u{\\left(t,x,y \\right)} + \\frac{\\partial^{2}}{\\partial y^{2}} u{\\left(t,x,y \\right)} + \\frac{\\partial^{2}}{\\partial t^{2}} v{\\left(t,x,y \\right)}$"
      ],
      "text/plain": [
       "Derivative(u(t, x, y), (x, 2)) + Derivative(u(t, x, y), (y, 2)) + Derivative(v(t, x, y), (t, 2))"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.dt2 + u.laplace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial^{2}}{\\partial x^{2}} \\left(\\frac{\\partial^{2}}{\\partial x^{2}} u{\\left(t,x,y \\right)} + \\frac{\\partial^{2}}{\\partial y^{2}} u{\\left(t,x,y \\right)} + \\frac{\\partial^{2}}{\\partial t^{2}} v{\\left(t,x,y \\right)}\\right)$"
      ],
      "text/plain": [
       "Derivative(Derivative(u(t, x, y), (x, 2)) + Derivative(u(t, x, y), (y, 2)) + Derivative(v(t, x, y), (t, 2)), (x, 2))"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(v.dt2 + u.laplace).dx2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Which can, depending on the chosen discretisation, lead to fairly complex stencils: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{2.0 \\left(- \\frac{2.0 u{\\left(t,x,y \\right)}}{h_{y}^{2}} + \\frac{u{\\left(t,x,y - h_{y} \\right)}}{h_{y}^{2}} + \\frac{u{\\left(t,x,y + h_{y} \\right)}}{h_{y}^{2}} - \\frac{2.0 u{\\left(t,x,y \\right)}}{h_{x}^{2}} + \\frac{u{\\left(t,x - h_{x},y \\right)}}{h_{x}^{2}} + \\frac{u{\\left(t,x + h_{x},y \\right)}}{h_{x}^{2}} - \\frac{2.0 v{\\left(t,x,y \\right)}}{dt^{2}} + \\frac{v{\\left(t - dt,x,y \\right)}}{dt^{2}} + \\frac{v{\\left(t + dt,x,y \\right)}}{dt^{2}}\\right)}{h_{x}^{2}} + \\frac{- \\frac{2.0 u{\\left(t,x - h_{x},y \\right)}}{h_{y}^{2}} + \\frac{u{\\left(t,x - h_{x},y - h_{y} \\right)}}{h_{y}^{2}} + \\frac{u{\\left(t,x - h_{x},y + h_{y} \\right)}}{h_{y}^{2}} + \\frac{u{\\left(t,x,y \\right)}}{h_{x}^{2}} + \\frac{u{\\left(t,x - 2 h_{x},y \\right)}}{h_{x}^{2}} - \\frac{2.0 u{\\left(t,x - h_{x},y \\right)}}{h_{x}^{2}} - \\frac{2.0 v{\\left(t,x - h_{x},y \\right)}}{dt^{2}} + \\frac{v{\\left(t - dt,x - h_{x},y \\right)}}{dt^{2}} + \\frac{v{\\left(t + dt,x - h_{x},y \\right)}}{dt^{2}}}{h_{x}^{2}} + \\frac{- \\frac{2.0 u{\\left(t,x + h_{x},y \\right)}}{h_{y}^{2}} + \\frac{u{\\left(t,x + h_{x},y - h_{y} \\right)}}{h_{y}^{2}} + \\frac{u{\\left(t,x + h_{x},y + h_{y} \\right)}}{h_{y}^{2}} + \\frac{u{\\left(t,x,y \\right)}}{h_{x}^{2}} - \\frac{2.0 u{\\left(t,x + h_{x},y \\right)}}{h_{x}^{2}} + \\frac{u{\\left(t,x + 2 h_{x},y \\right)}}{h_{x}^{2}} - \\frac{2.0 v{\\left(t,x + h_{x},y \\right)}}{dt^{2}} + \\frac{v{\\left(t - dt,x + h_{x},y \\right)}}{dt^{2}} + \\frac{v{\\left(t + dt,x + h_{x},y \\right)}}{dt^{2}}}{h_{x}^{2}}$"
      ],
      "text/plain": [
       "-2.0*(-2.0*u(t, x, y)/h_y**2 + u(t, x, y - h_y)/h_y**2 + u(t, x, y + h_y)/h_y**2 - 2.0*u(t, x, y)/h_x**2 + u(t, x - h_x, y)/h_x**2 + u(t, x + h_x, y)/h_x**2 - 2.0*v(t, x, y)/dt**2 + v(t - dt, x, y)/dt**2 + v(t + dt, x, y)/dt**2)/h_x**2 + (-2.0*u(t, x - h_x, y)/h_y**2 + u(t, x - h_x, y - h_y)/h_y**2 + u(t, x - h_x, y + h_y)/h_y**2 + u(t, x, y)/h_x**2 + u(t, x - 2*h_x, y)/h_x**2 - 2.0*u(t, x - h_x, y)/h_x**2 - 2.0*v(t, x - h_x, y)/dt**2 + v(t - dt, x - h_x, y)/dt**2 + v(t + dt, x - h_x, y)/dt**2)/h_x**2 + (-2.0*u(t, x + h_x, y)/h_y**2 + u(t, x + h_x, y - h_y)/h_y**2 + u(t, x + h_x, y + h_y)/h_y**2 + u(t, x, y)/h_x**2 - 2.0*u(t, x + h_x, y)/h_x**2 + u(t, x + 2*h_x, y)/h_x**2 - 2.0*v(t, x + h_x, y)/dt**2 + v(t - dt, x + h_x, y)/dt**2 + v(t + dt, x + h_x, y)/dt**2)/h_x**2"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(v.dt2 + u.laplace).dx2.evaluate"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
